home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / haziran / 19 / setup.exe / data.z / p9060_lib.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-04-11  |  20.8 KB  |  657 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - P9060_LIB.C
  3. //
  4. // Library for 'WinDriver for PLX 9060' API. 
  5. // The basic idea is to get a handle for the board
  6. // with P9060_Open() and use it in the rest of the program
  7. // when calling WD functions.  Call P9060_Close() when done.
  8. // 
  9. ////////////////////////////////////////////////////////////////
  10.  
  11. #include "../../../include/windrvr.h"
  12. #include "../../../include/windrvr_int_thread.h"
  13. #include "p9060_lib.h"
  14. #include <stdio.h>
  15.  
  16. // this string is set to an error message, if one occurs
  17. CHAR P9060_ErrorString[1024];
  18.  
  19. // internal function used by P9060_Open()
  20. BOOL P9060_DetectCardElements(P9060_HANDLE hPlx);
  21. // internal function used by P9060_Read... and P9060_Write... functions
  22. void P9060_SetMode (P9060_HANDLE hPlx, P9060_MODE mode, DWORD dwLocalAddr);
  23.  
  24. DWORD P9060_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
  25. {
  26.     WD_VERSION ver;
  27.     WD_PCI_SCAN_CARDS pciScan;
  28.     HANDLE hWD = INVALID_HANDLE_VALUE;
  29.  
  30.     P9060_ErrorString[0] = '\0';
  31.     hWD = WD_Open();
  32.     // check if handle valid & version OK
  33.     if (hWD==INVALID_HANDLE_VALUE) 
  34.     {
  35.         sprintf( P9060_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  36.         return 0;
  37.     }
  38.  
  39.     BZERO(ver);
  40.     WD_Version(hWD,&ver);
  41.     if (ver.dwVer<WD_VER) 
  42.     {
  43.         sprintf( P9060_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  44.         WD_Close (hWD);
  45.         return 0;
  46.     }
  47.  
  48.     BZERO(pciScan);
  49.     pciScan.searchId.dwVendorId = dwVendorID;
  50.     pciScan.searchId.dwDeviceId = dwDeviceID;
  51.     WD_PciScanCards (hWD, &pciScan);
  52.     WD_Close (hWD);
  53.     if (pciScan.dwCards==0)
  54.         sprintf( P9060_ErrorString, "no cards found\n");
  55.     return pciScan.dwCards;
  56. }
  57.  
  58.  
  59. BOOL P9060_Open (P9060_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum, DWORD dwOptions)
  60. {
  61.     P9060_HANDLE hPlx = (P9060_HANDLE) malloc (sizeof (P9060_STRUCT));
  62.     DWORD dwIntStatus;
  63.  
  64.     WD_VERSION ver;
  65.     WD_PCI_SCAN_CARDS pciScan;
  66.     WD_PCI_CARD_INFO pciCardInfo;
  67.  
  68.     *phPlx = NULL;
  69.     P9060_ErrorString[0] = '\0';
  70.     BZERO(*hPlx);
  71.  
  72.     hPlx->hWD = WD_Open();
  73.  
  74.     // check if handle valid & version OK
  75.     if (hPlx->hWD==INVALID_HANDLE_VALUE) 
  76.     {
  77.         sprintf( P9060_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  78.         goto Exit;
  79.     }
  80.  
  81.     BZERO(ver);
  82.     WD_Version(hPlx->hWD,&ver);
  83.     if (ver.dwVer<WD_VER) 
  84.     {
  85.         sprintf( P9060_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  86.         goto Exit;
  87.     }
  88.  
  89.     BZERO(pciScan);
  90.     pciScan.searchId.dwVendorId = dwVendorID;
  91.     pciScan.searchId.dwDeviceId = dwDeviceID;
  92.     WD_PciScanCards (hPlx->hWD, &pciScan);
  93.     if (pciScan.dwCards==0) // Found at least one card
  94.     {
  95.         sprintf( P9060_ErrorString, "Could not find PCI card\n");
  96.         goto Exit;
  97.     }
  98.     if (pciScan.dwCards<=nCardNum)
  99.     {
  100.         sprintf( P9060_ErrorString, "Card out of range of available cards\n");
  101.         goto Exit;
  102.     }
  103.  
  104.     BZERO(pciCardInfo);
  105.     pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
  106.     WD_PciGetCardInfo (hPlx->hWD, &pciCardInfo);
  107.     hPlx->pciSlot = pciCardInfo.pciSlot;
  108.     hPlx->cardReg.Card = pciCardInfo.Card;
  109.  
  110.     hPlx->fUseInt = (dwOptions & P9060_OPEN_USE_INT) ? TRUE : FALSE;
  111.     if (!hPlx->fUseInt)
  112.     {
  113.         DWORD i;
  114.         // Remove interrupt item if not needed
  115.         for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  116.         {
  117.             WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  118.             if (pItem->item==ITEM_INTERRUPT)
  119.                 pItem->item = ITEM_NONE;
  120.         }
  121.     }
  122.     else
  123.     {
  124.         DWORD i;
  125.         // make interrupt resource sharable
  126.         for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  127.         {
  128.             WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  129.             if (pItem->item==ITEM_INTERRUPT)
  130.                 pItem->fNotSharable = FALSE;
  131.         }
  132.     }
  133.  
  134.     hPlx->cardReg.fCheckLockOnly = FALSE;
  135.     WD_CardRegister (hPlx->hWD, &hPlx->cardReg);
  136.     if (hPlx->cardReg.hCard==0)
  137.     {
  138.         sprintf ( P9060_ErrorString, "Failed locking device\n");
  139.         goto Exit;
  140.     }
  141.  
  142.     if (!P9060_DetectCardElements(hPlx))
  143.     {
  144.         sprintf ( P9060_ErrorString, "Card does not have all items expected for PLX 9060\n");
  145.         goto Exit;
  146.     }
  147.  
  148.     // set the values to be written to REGION_DESC register
  149.     hPlx->modeDesc[P9060_MODE_BYTE] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_BYTE);
  150.     hPlx->modeDesc[P9060_MODE_WORD] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_WORD);
  151.     hPlx->modeDesc[P9060_MODE_DWORD] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_DWORD);
  152.  
  153.     // this enables target abort so it wont get stuck 
  154.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  155.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus | BIT12);
  156.  
  157.     // Open finished OK
  158.     *phPlx = hPlx;
  159.     return TRUE;
  160.  
  161. Exit:
  162.     // Error durin Open
  163.     if (hPlx->cardReg.hCard) 
  164.         WD_CardUnregister(hPlx->hWD, &hPlx->cardReg);
  165.     if (hPlx->hWD!=INVALID_HANDLE_VALUE)
  166.         WD_Close(hPlx->hWD);
  167.     free (hPlx);
  168.     return FALSE;
  169. }
  170.  
  171. DWORD P9060_ReadPCIReg(P9060_HANDLE hPlx, DWORD dwReg)
  172. {
  173.     WD_PCI_CONFIG_DUMP pciCnf;
  174.     DWORD dwVal;
  175.  
  176.     BZERO (pciCnf);
  177.     pciCnf.pciSlot = hPlx->pciSlot;
  178.     pciCnf.pBuffer = &dwVal;
  179.     pciCnf.dwOffset = dwReg;
  180.     pciCnf.dwBytes = 4;
  181.     pciCnf.fIsRead = TRUE;
  182.     WD_PciConfigDump(hPlx->hWD,&pciCnf);
  183.     return dwVal;
  184. }
  185.  
  186. void P9060_WritePCIReg(P9060_HANDLE hPlx, DWORD dwReg, DWORD dwData)
  187. {
  188.     WD_PCI_CONFIG_DUMP pciCnf;
  189.  
  190.     BZERO (pciCnf);
  191.     pciCnf.pciSlot = hPlx->pciSlot;
  192.     pciCnf.pBuffer = &dwData;
  193.     pciCnf.dwOffset = dwReg;
  194.     pciCnf.dwBytes = 4;
  195.     pciCnf.fIsRead = FALSE;
  196.     WD_PciConfigDump(hPlx->hWD,&pciCnf);
  197. }
  198.  
  199. BOOL P9060_DetectCardElements(P9060_HANDLE hPlx)
  200. {
  201.     DWORD i;
  202.     DWORD ad_sp;
  203.  
  204.     BZERO(hPlx->Int);
  205.     BZERO(hPlx->addrDesc);
  206.  
  207.     for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  208.     {
  209.         WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  210.  
  211.         switch (pItem->item)
  212.         {
  213.         case ITEM_MEMORY:
  214.         case ITEM_IO:
  215.             {
  216.                 DWORD dwBytes;
  217.                 DWORD dwAddr;
  218.                 DWORD dwPhysAddr;
  219.                 DWORD dwAddrDirect = 0;
  220.                 BOOL fIsMemory;
  221.                 if (pItem->item==ITEM_MEMORY)
  222.                 {
  223.                     dwBytes = pItem->I.Mem.dwBytes;
  224.                     dwAddr = pItem->I.Mem.dwTransAddr;
  225.                     dwAddrDirect = pItem->I.Mem.dwUserDirectAddr;
  226.                     dwPhysAddr = pItem->I.Mem.dwPhysicalAddr;
  227.                     fIsMemory = TRUE;
  228.                 }
  229.                 else 
  230.                 {
  231.                     dwBytes = pItem->I.IO.dwBytes;
  232.                     dwAddr = pItem->I.IO.dwAddr;
  233.                     dwPhysAddr = dwAddr & 0xffff;
  234.                     fIsMemory = FALSE;
  235.                 }
  236.  
  237.                 for (ad_sp=P9060_ADDR_REG; ad_sp<=P9060_ADDR_EPROM; ad_sp++)
  238.                 {
  239.                     DWORD dwPCIAddr;
  240.                     DWORD dwPCIReg;
  241.  
  242.                     if (hPlx->addrDesc[ad_sp].dwAddr) continue;
  243.                     if (ad_sp==P9060_ADDR_REG) dwPCIReg = PCI_BAR0;
  244.                     else if (ad_sp<P9060_ADDR_EPROM) 
  245.                         dwPCIReg = PCI_BAR2 + 4*(ad_sp-P9060_ADDR_SPACE0);
  246.                     else dwPCIReg = PCI_ERBAR;
  247.                     dwPCIAddr = P9060_ReadPCIReg(hPlx, dwPCIReg);
  248.                     if (dwPCIAddr & 1)
  249.                     {
  250.                         if (fIsMemory) continue;
  251.                         dwPCIAddr &= ~0x3;
  252.                     }
  253.                     else
  254.                     {
  255.                         if (!fIsMemory) continue;
  256.                         dwPCIAddr &= ~0xf;
  257.                     }
  258.                     if (dwPCIAddr==dwPhysAddr)
  259.                         break;
  260.                 }
  261.                 if (ad_sp<=P9060_ADDR_EPROM)
  262.                 {
  263.                     DWORD j;
  264.                     hPlx->addrDesc[ad_sp].dwBytes = dwBytes;
  265.                     hPlx->addrDesc[ad_sp].dwAddr = dwAddr;
  266.                     hPlx->addrDesc[ad_sp].dwAddrDirect = dwAddrDirect;
  267.                     hPlx->addrDesc[ad_sp].fIsMemory = fIsMemory;
  268.                     hPlx->addrDesc[ad_sp].dwMask = 0;
  269.                     for (j=1; j<hPlx->addrDesc[ad_sp].dwBytes && j!=0x80000000; j *= 2)
  270.                     {
  271.                         hPlx->addrDesc[ad_sp].dwMask = 
  272.                             (hPlx->addrDesc[ad_sp].dwMask << 1) | 1;
  273.                     }
  274.                 }
  275.             }
  276.             break;
  277.         case ITEM_INTERRUPT:
  278.             if (hPlx->Int.Int.hInterrupt) return FALSE;
  279.             hPlx->Int.Int.hInterrupt = pItem->I.Int.hInterrupt;
  280.             break;
  281.         }
  282.     }
  283.  
  284.     // check that all the items needed were found
  285.     // check if interrupt found
  286.     if (hPlx->fUseInt && !hPlx->Int.Int.hInterrupt) 
  287.     {
  288.         return FALSE;
  289.     }
  290.  
  291.     // check that the registers space was found
  292.     if (!P9060_IsAddrSpaceActive(hPlx, P9060_ADDR_REG)) 
  293.             //|| hPlx->addrDesc[P9060_ADDR_REG].dwBytes!=P9060_RANGE_REG)
  294.         return FALSE;
  295.  
  296.     // check that address space 0 was found
  297.     if (!P9060_IsAddrSpaceActive(hPlx, P9060_ADDR_SPACE0)) return FALSE;
  298.     hPlx->addrSpace = P9060_ADDR_SPACE0;
  299.  
  300.     return TRUE;
  301. }
  302.  
  303. void P9060_Close(P9060_HANDLE hPlx)
  304. {
  305.     // disable interrupts
  306.     if (P9060_IntIsEnabled(hPlx))
  307.         P9060_IntDisable(hPlx);
  308.  
  309.     // unregister card
  310.     if (hPlx->cardReg.hCard) 
  311.         WD_CardUnregister(hPlx->hWD, &hPlx->cardReg);
  312.  
  313.     // close WinDriver
  314.     WD_Close(hPlx->hWD);
  315.  
  316.     free (hPlx);
  317. }
  318.  
  319. BOOL P9060_IsAddrSpaceActive(P9060_HANDLE hPlx, P9060_ADDR addrSpace)
  320. {
  321.     return hPlx->addrDesc[addrSpace].dwAddr!=0;
  322. }
  323.  
  324. DWORD P9060_ReadReg (P9060_HANDLE hPlx, DWORD dwReg)
  325. {
  326.     return P9060_ReadSpaceDWord(hPlx, P9060_ADDR_REG, dwReg);
  327. }
  328.  
  329. void P9060_WriteReg (P9060_HANDLE hPlx, DWORD dwReg, DWORD dwData)
  330. {
  331.     P9060_WriteSpaceDWord(hPlx, P9060_ADDR_REG, dwReg, dwData);
  332. }
  333.  
  334. BYTE P9060_ReadSpaceByte (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  335. {
  336.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  337.     {
  338.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  339.         BYTE *pByte = (BYTE *) dwAddr;
  340.         return *pByte;
  341.     }
  342.     else
  343.     {
  344.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  345.         WD_TRANSFER trans;
  346.         BZERO(trans);
  347.         trans.cmdTrans = RP_BYTE;
  348.         trans.dwPort = dwAddr;
  349.         WD_Transfer (hPlx->hWD, &trans);
  350.         return trans.Data.Byte;
  351.     }
  352. }
  353.  
  354. void P9060_WriteSpaceByte (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, BYTE data)
  355. {
  356.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  357.     {
  358.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  359.         BYTE *pByte = (BYTE *) dwAddr;
  360.         *pByte = data;
  361.     }
  362.     else
  363.     {
  364.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  365.         WD_TRANSFER trans;
  366.         BZERO(trans);
  367.         trans.cmdTrans = WP_BYTE;
  368.         trans.dwPort = dwAddr;
  369.         trans.Data.Byte = data;
  370.         WD_Transfer (hPlx->hWD, &trans);
  371.     }
  372. }
  373.  
  374. WORD P9060_ReadSpaceWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  375. {
  376.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  377.     {
  378.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  379.         WORD *pWord = (WORD *) dwAddr;
  380.         return *pWord;
  381.     }
  382.     else
  383.     {
  384.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  385.         WD_TRANSFER trans;
  386.         BZERO(trans);
  387.         trans.cmdTrans = RP_WORD;
  388.         trans.dwPort = dwAddr;
  389.         WD_Transfer (hPlx->hWD, &trans);
  390.         return trans.Data.Word;
  391.     }
  392. }
  393.  
  394. void P9060_WriteSpaceWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, WORD data)
  395. {
  396.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  397.     {
  398.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  399.         WORD *pWord = (WORD *) dwAddr;
  400.         *pWord = data;
  401.     }
  402.     else
  403.     {
  404.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  405.         WD_TRANSFER trans;
  406.         BZERO(trans);
  407.         trans.cmdTrans = WP_WORD;
  408.         trans.dwPort = dwAddr;
  409.         trans.Data.Word = data;
  410.         WD_Transfer (hPlx->hWD, &trans);
  411.     }
  412. }
  413.  
  414. DWORD P9060_ReadSpaceDWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  415. {
  416.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  417.     {
  418.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  419.         DWORD *pDword = (DWORD *) dwAddr;
  420.         return *pDword;
  421.     }
  422.     else
  423.     {
  424.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  425.         WD_TRANSFER trans;
  426.         BZERO(trans);
  427.         trans.cmdTrans = RP_DWORD;
  428.         trans.dwPort = dwAddr;
  429.         WD_Transfer (hPlx->hWD, &trans);
  430.         return trans.Data.Dword;
  431.     }
  432. }
  433.  
  434. void P9060_WriteSpaceDWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, DWORD data)
  435. {
  436.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  437.     {
  438.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  439.         DWORD *pDword = (DWORD *) dwAddr;
  440.         *pDword = data;
  441.     }
  442.     else
  443.     {
  444.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  445.         WD_TRANSFER trans;
  446.         BZERO(trans);
  447.         trans.cmdTrans = WP_DWORD;
  448.         trans.dwPort = dwAddr;
  449.         trans.Data.Dword = data;
  450.         WD_Transfer (hPlx->hWD, &trans);
  451.     }
  452. }
  453.  
  454. void P9060_ReadWriteSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  455.                     DWORD dwBytes, BOOL fIsRead, P9060_ADDR addrSpace, P9060_MODE mode)
  456. {
  457.     DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  458.     WD_TRANSFER trans;
  459.  
  460.     BZERO(trans);
  461.  
  462.     if (hPlx->addrDesc[addrSpace].fIsMemory) 
  463.     {
  464.         if (fIsRead) 
  465.         {
  466.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
  467.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = RM_SWORD;
  468.             else trans.cmdTrans = RM_SDWORD;
  469.         }
  470.         else 
  471.         {
  472.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
  473.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = WM_SWORD;
  474.             else trans.cmdTrans = WM_SDWORD;
  475.         }
  476.     }
  477.     else 
  478.     {
  479.         if (fIsRead) 
  480.         {
  481.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
  482.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = RP_SWORD;
  483.             else trans.cmdTrans = RP_SDWORD;
  484.         }
  485.         else 
  486.         {
  487.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
  488.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = WP_SWORD;
  489.             else trans.cmdTrans = WP_SDWORD;
  490.         }
  491.     }
  492.     trans.dwPort = dwAddr;
  493.     trans.fAutoinc = TRUE;
  494.     trans.dwBytes = dwBytes;
  495.     trans.dwOptions = 0;
  496.     trans.Data.pBuffer = buf;
  497.     WD_Transfer (hPlx->hWD, &trans);
  498. }
  499.  
  500. void P9060_ReadSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  501.                     DWORD dwBytes, P9060_ADDR addrSpace, P9060_MODE mode)
  502. {
  503.     P9060_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
  504. }
  505.  
  506. void P9060_WriteSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  507.                      DWORD dwBytes, P9060_ADDR addrSpace, P9060_MODE mode)
  508. {
  509.     P9060_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
  510. }
  511.  
  512. void P9060_SetMode (P9060_HANDLE hPlx, P9060_MODE mode, DWORD dwLocalAddr)
  513. {
  514.     P9060_WriteReg (hPlx, P9060_REGION_DESC, hPlx->modeDesc[mode]);
  515.     hPlx->addrDesc[hPlx->addrSpace].dwLocalBase = dwLocalAddr & ~hPlx->addrDesc[hPlx->addrSpace].dwMask;
  516.     hPlx->addrDesc[hPlx->addrSpace].dwLocalBase |= BIT0;
  517.     P9060_WriteReg (hPlx, P9060_REMAP_PTOL_0, hPlx->addrDesc[hPlx->addrSpace].dwLocalBase);
  518. }
  519.  
  520. BYTE P9060_ReadByte (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  521. {
  522.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  523.     P9060_SetMode (hPlx, P9060_MODE_BYTE, dwLocalAddr);
  524.     return P9060_ReadSpaceByte(hPlx, hPlx->addrSpace, dwOffset);
  525. }
  526.  
  527. void P9060_WriteByte (P9060_HANDLE hPlx, DWORD dwLocalAddr, BYTE data)
  528. {
  529.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  530.     P9060_SetMode (hPlx, P9060_MODE_BYTE, dwLocalAddr);
  531.     P9060_WriteSpaceByte(hPlx, hPlx->addrSpace, dwOffset, data);
  532. }
  533.  
  534. WORD P9060_ReadWord (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  535. {
  536.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  537.     P9060_SetMode (hPlx, P9060_MODE_WORD, dwLocalAddr);
  538.     return P9060_ReadSpaceWord(hPlx, hPlx->addrSpace, dwOffset);
  539. }
  540.  
  541. void P9060_WriteWord (P9060_HANDLE hPlx, DWORD dwLocalAddr, WORD data)
  542. {
  543.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  544.     P9060_SetMode (hPlx, P9060_MODE_WORD, dwLocalAddr);
  545.     P9060_WriteSpaceWord(hPlx, hPlx->addrSpace, dwOffset, data);
  546. }
  547.  
  548. DWORD P9060_ReadDWord (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  549. {
  550.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  551.     P9060_SetMode (hPlx, P9060_MODE_DWORD, dwLocalAddr);
  552.     return P9060_ReadSpaceDWord(hPlx, hPlx->addrSpace, dwOffset);
  553. }
  554.  
  555. void P9060_WriteDWord (P9060_HANDLE hPlx, DWORD dwLocalAddr, DWORD data)
  556. {
  557.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  558.     P9060_SetMode (hPlx, P9060_MODE_DWORD, dwLocalAddr);
  559.     P9060_WriteSpaceDWord(hPlx, hPlx->addrSpace, dwOffset, data);
  560. }
  561.  
  562. void P9060_ReadWriteBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  563.                     DWORD dwBytes, BOOL fIsRead, P9060_MODE mode)
  564. {
  565.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  566.     P9060_SetMode (hPlx, mode, dwLocalAddr);
  567.     P9060_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, hPlx->addrSpace, mode);
  568. }
  569.  
  570. void P9060_ReadBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  571.                     DWORD dwBytes, P9060_MODE mode)
  572. {
  573.     P9060_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, mode);
  574. }
  575.  
  576. void P9060_WriteBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  577.                      DWORD dwBytes, P9060_MODE mode)
  578. {
  579.     P9060_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, mode);
  580. }
  581.  
  582. BOOL P9060_IntIsEnabled (P9060_HANDLE hPlx)
  583. {
  584.     if (!hPlx->fUseInt) return FALSE;
  585.     if (!hPlx->Int.hThread) return FALSE;
  586.     return TRUE;
  587. }
  588.  
  589. VOID P9060_IntHandler (PVOID pData)
  590. {
  591.     P9060_HANDLE hPlx = (P9060_HANDLE) pData;
  592.     P9060_INT_RESULT intResult;
  593.  
  594.     intResult.dwCounter = hPlx->Int.Int.dwCounter;
  595.     intResult.dwLost = hPlx->Int.Int.dwLost;
  596.     intResult.fStopped = hPlx->Int.Int.fStopped;
  597.     intResult.dwStatusReg = hPlx->Int.Trans[0].Data.Dword;
  598.     hPlx->Int.funcIntHandler(hPlx, &intResult);
  599. }
  600.  
  601. BOOL P9060_IntEnable (P9060_HANDLE hPlx, P9060_INT_HANDLER funcIntHandler)
  602. {
  603.     DWORD dwIntStatus;
  604.     DWORD dwAddr;
  605.  
  606.     if (!hPlx->fUseInt) return FALSE;
  607.     // check if interrupt is already enabled
  608.     if (hPlx->Int.hThread) return FALSE;
  609.  
  610.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  611.  
  612.     BZERO(hPlx->Int.Trans);
  613.     // This is a samlpe of handling interrupts:
  614.     // Two transfer commands are issued. First the value of the interrrupt control/status
  615.     // register is read. Then, a value of ZERO is written.
  616.     // This will cancel interrupts after the first interrupt occurs.
  617.     // When using interrupts, this section will have to change:
  618.     // you must put transfer commands to CANCEL the source of the interrupt, otherwise, the 
  619.     // PC will hang when an interrupt occurs!
  620.     dwAddr = hPlx->addrDesc[P9060_ADDR_REG].dwAddr + P9060_INT_STATUS;
  621.     hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[P9060_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
  622.     hPlx->Int.Trans[0].dwPort = dwAddr;
  623.     hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[P9060_ADDR_REG].fIsMemory ? WM_DWORD : WP_DWORD;
  624.     hPlx->Int.Trans[1].dwPort = dwAddr;
  625.     hPlx->Int.Trans[1].Data.Dword = dwIntStatus & ~(BIT8|BIT10); // put here the data to write to the control register
  626.     hPlx->Int.Int.dwCmds = 2; 
  627.     hPlx->Int.Int.Cmd = hPlx->Int.Trans;
  628.     hPlx->Int.Int.dwOptions |= INTERRUPT_CMD_COPY;
  629.  
  630.     // create interrupt handler thread
  631.     hPlx->Int.funcIntHandler = funcIntHandler;
  632.     if (!InterruptThreadEnable(&hPlx->Int.hThread, hPlx->hWD, &hPlx->Int.Int, P9060_IntHandler, (PVOID) hPlx))
  633.         return FALSE;
  634.  
  635.     // this enables interrupts
  636.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus | (BIT8|BIT10));
  637.  
  638.     return TRUE;
  639. }
  640.  
  641. void P9060_IntDisable (P9060_HANDLE hPlx)
  642. {
  643.     DWORD dwIntStatus;
  644.  
  645.     if (!hPlx->fUseInt) return;
  646.     if (!hPlx->Int.hThread) return;
  647.  
  648.     // this disables interrupts
  649.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  650.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus & ~(BIT8|BIT10));
  651.  
  652.     // this calls WD_IntDisable()
  653.     InterruptThreadDisable(hPlx->Int.hThread);
  654.     hPlx->Int.hThread = NULL;
  655. }
  656.  
  657.